import rhchInit from './rhchInit';
import formula from './formula';
import editor from './editor';
import { setcellvalue } from './setdata';
import { getcellFormula } from './getdata';
import { computeRowlenArr } from './getRowlen';
import {
    luckysheetDrawMain,
    luckysheetDrawgridRowTitle,
    luckysheetDrawgridColumnTitle
} from './draw';
import luckysheetFreezen from '../controllers/freezen';
import server from '../controllers/server';
import sheetmanage from '../controllers/sheetmanage';
import luckysheetPostil from '../controllers/postil';
import dataVerificationCtrl from '../controllers/dataVerificationCtrl';
import hyperlinkCtrl from '../controllers/hyperlinkCtrl';
import { selectHightlightShow, selectionCopyShow, collaborativeEditBox } from '../controllers/select';
import { createFilterOptions } from '../controllers/filter';
import { getSheetIndex } from '../methods/get';
import Store from '../store';
import attachmentCtrl from '../controllers/loadAttechment';
import { getCurrentSheetIndex } from './api';

let refreshCanvasTimeOut = null;

function runExecFunction (range, index, data) {
    formula.execFunctionExist = [];
    for (let s = 0; s < range.length; s++) {
        for (let r = range[s].row[0]; r <= range[s].row[1]; r++) {
            for (let c = range[s].column[0]; c <= range[s].column[1]; c++) {
                formula.execFunctionExist.push({ "r": r, "c": c, "i": index });
            }
        }
    }
    formula.execFunctionExist.reverse();
    formula.execFunctionGroup(null, null, null, null, data);
    formula.execFunctionGlobalData = null;
}

function jfrefreshgrid (data, range, allParam, isRunExecFunction = true, isRefreshCanvas = true, isReCreateAssistCanvas = true) {
    if (data == null) {
        data = Store.flowdata;
    }

    if (range == null) {
        range = Store.luckysheet_select_save;
    }
    range = JSON.parse(JSON.stringify(range));

    clearTimeout(refreshCanvasTimeOut);

    // 关联参数
    if (allParam == null) {
        allParam = {};
    }

    let cfg = allParam.cfg;  // config
    let RowlChange = allParam.RowlChange;  // 行高改变
    let cdformat = allParam.cdformat;  // 条件格式
    let dataVerification = allParam.dataVerification;  // 数据验证
    let dynamicArray = allParam.dynamicArray;  // 动态数组

    let file = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)];

    if (Store.clearjfundo  && !Store.suspend) {
        Store.jfundo.length  = 0;

        let curConfig;
        if (cfg == null) {
            curConfig = $.extend(true, {}, Store.config);
        } else {
            curConfig = $.extend(true, {}, cfg);
        }

        let curCdformat;
        if (cdformat == null) {
            curCdformat = $.extend(true, [], file.luckysheet_conditionformat_save);
        } else {
            curCdformat = cdformat;
        }

        let curDataVerification;
        if (dataVerification == null) {
            curDataVerification = $.extend(true, {}, file.dataVerification);
        } else {
            curDataVerification = dataVerification;
        }

        let curDynamicArray;
        if (dynamicArray == null) {
            curDynamicArray = $.extend(true, [], file.dynamicArray);
        } else {
            curDynamicArray = dynamicArray;
        }

        Store.jfredo.push({
            "type": "datachange",
            "data": Store.flowdata,
            "curdata": data,
            "sheetIndex": Store.currentSheetIndex,
            "config": $.extend(true, {}, Store.config),
            "curConfig": curConfig,
            "cdformat": $.extend(true, [], file.luckysheet_conditionformat_save),
            "curCdformat": curCdformat,
            "RowlChange": RowlChange,
            "dataVerification": $.extend(true, [], file.dataVerification),
            "curDataVerification": curDataVerification,
            "dynamicArray": $.extend(true, [], file.dynamicArray),
            "curDynamicArray": curDynamicArray,
            "range": range,
            "dataRange": [...file.luckysheet_select_save]// 保留操作时的选区
        });
    }

    // Store.flowdata
    Store.flowdata = data;
    // editor.webWorkerFlowDataCache(Store.flowdata);// worker存数据
    file.data = Store.flowdata;

    // 必须要处理，可能之前的config为空，则也需要清空
    if (cfg != null) {
        Store.config = cfg;
        file.config = Store.config;

        server.saveParam("all", Store.currentSheetIndex, cfg, { "k": "config" });

        if (RowlChange != null) {
            jfrefreshgrid_rhcw(Store.flowdata.length, Store.flowdata[0].length, true, isReCreateAssistCanvas);
        }
    }

    // condition format, null or empty array are not processed
    if (cdformat != null && cdformat.length !== 0) {
        file.luckysheet_conditionformat_save = cdformat;

        server.saveParam("all", Store.currentSheetIndex, cdformat, { "k": "luckysheet_conditionformat_save" });
    }

    // data Verification, null or empty object are not processed
    if (dataVerification != null && Object.keys(dataVerification).length !== 0) {
        dataVerificationCtrl.dataVerification = dataVerification;
        file.dataVerification = dataVerification;
        server.saveParam("all", Store.currentSheetIndex, dataVerification, { "k": "dataVerification" });
    }

    // 动态数组
    if (dynamicArray != null) {
        file.dynamicArray = dynamicArray;

        server.saveParam("all", Store.currentSheetIndex, dynamicArray, { "k": "dynamicArray" });
    }

    // 更新数据的范围
    for (let s = 0; s < range.length; s++) {
        let r1 = range[s].row[0];
        let c1 = range[s].column[0];

        if (Store.flowdata[r1][c1] != null && Store.flowdata[r1][c1].spl != null) {
            window.luckysheetCurrentRow = r1;
            window.luckysheetCurrentColumn = c1;
            window.luckysheetCurrentFunction = Store.flowdata[r1][c1].f;

            let fp = $.trim(formula.functionParserExe(Store.flowdata[r1][c1].f));
            let sparklines = new Function("return " + fp)();
            Store.flowdata[r1][c1].spl = sparklines;
        }

        if (server.allowUpdate) { // 共享编辑模式
            server.historyParam(Store.flowdata, Store.currentSheetIndex, range[s]);
        }
        // 刷新图表
        if (typeof (Store.chartparam.jfrefreshchartall) == "function") {
            Store.chartparam.jfrefreshchartall(Store.flowdata, range[s].row[0], range[s].row[1], range[s].column[0], range[s].column[1]);
        }
    }
    // 单元格数据更新联动
    if (isRunExecFunction) {
        runExecFunction(range, Store.currentSheetIndex, data);
    }
    // 刷新表格
    if (isRefreshCanvas) {
        refreshCanvasTimeOut = setTimeout(function () {
            luckysheetrefreshgrid();
        }, 1);
    }

    /* 选区同步 */
    if (!Store.suspend) selectHightlightShow();
    window.luckysheet_getcelldata_cache = null;
}

function jfrefreshgridall (colwidth, rowheight, data, cfg, range, ctrlType, ctrlValue, cdformat, isRefreshCanvas = true) {
    let redo = {}, isRunExecFunction = false;
    clearTimeout(refreshCanvasTimeOut);
    if (ctrlType == "cellRowChange") {
        redo.type = "cellRowChange";
        redo.config = $.extend(true, {}, Store.config);
        redo.curconfig = $.extend(true, {}, cfg);

        redo.range = $.extend(true, [], Store.luckysheet_select_save);
        redo.currange = range;

        redo.ctrlType = ctrlType;
        redo.ctrlValue = ctrlValue;

        let setfield = cfg.rowlen;

        if (setfield == null) {
            setfield = {};
        }

        server.saveParam("cg", Store.currentSheetIndex, setfield, { "k": "rowlen" });
    } else if (ctrlType == "resizeC") {
        redo.type = "resize";
        redo.config = $.extend(true, {}, Store.config);
        redo.curconfig = $.extend(true, {}, cfg);

        redo.range = $.extend(true, [], Store.luckysheet_select_save);
        redo.currange = range;

        redo.ctrlType = ctrlType;
        redo.ctrlValue = ctrlValue;

        let setfield = cfg.columnlen;

        if (setfield == null) {
            setfield = {};
        }

        server.saveParam("cg", Store.currentSheetIndex, setfield, { "k": "columnlen" });
    } else if (ctrlType.indexOf("extend") > -1) {
        redo.type = "extend";
        redo.config = $.extend(true, {}, Store.config);
        redo.curconfig = $.extend(true, {}, cfg);

        redo.range = $.extend(true, [], Store.luckysheet_select_save);
        redo.currange = range;

        redo.ctrlType = ctrlType;
        redo.ctrlValue = ctrlValue;

        server.saveParam("arc", Store.currentSheetIndex, { "index": ctrlValue.index, "len": ctrlValue.len, "direction": ctrlValue.direction, "mc": cfg.merge }, { "rc": ctrlValue.type });
    } else if (ctrlType.indexOf("dele") > -1) {
        redo.type = "dele";
        redo.config = $.extend(true, {}, Store.config);
        redo.curconfig = $.extend(true, {}, cfg);

        redo.range = $.extend(true, [], Store.luckysheet_select_save);
        redo.currange = range;

        redo.ctrlType = ctrlType;
        redo.ctrlValue = ctrlValue;

        server.saveParam("drc", Store.currentSheetIndex, { "index": ctrlValue.index, "len": ctrlValue.len, "mc": cfg.merge, "borderInfo": cfg.borderInfo }, { "rc": ctrlValue.type });
    } else {
        redo.type = "datachangeAll";

        redo.range = $.extend(true, [], Store.luckysheet_select_save);
        redo.currange = range;

        redo.ctrlType = ctrlType;
        redo.ctrlValue = ctrlValue;

        isRunExecFunction = true;

        for (let s = 0; s < range.length; s++) {
            server.historyParam(data, Store.currentSheetIndex, range[s]);
        }
    }

    if (Store.clearjfundo) {
        Store.jfundo.length  = 0;

        redo.data = Store.flowdata;
        redo.curdata = data;
        redo.sheetIndex = Store.currentSheetIndex;
        redo.cdformat = $.extend(true, [], Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].luckysheet_conditionformat_save);
        redo.curCdformat = cdformat;

        Store.jfredo.push(redo);
    }

    // Store.flowdata
    Store.flowdata = data;
    Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].data = Store.flowdata;

    // config
    if (cfg != null) {
        Store.config = cfg;
        Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].config = Store.config;

        server.saveParam("all", Store.currentSheetIndex, cfg, { "k": "config" });
    }

    // 条件格式
    if (cdformat != null) {
        Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].luckysheet_conditionformat_save = cdformat;

        server.saveParam("all", Store.currentSheetIndex, cdformat, { "k": "luckysheet_conditionformat_save" });
    }

    // 选区
    Store.luckysheet_select_save = $.extend(true, [], range);
    if (Store.luckysheet_select_save.length > 0) {
        // 有选区时，刷新一下选区
        selectHightlightShow();
    }

    if (isRunExecFunction) {
        // 单元格数据更新联动
        runExecFunction(range, Store.currentSheetIndex, data);
    }

    // 行高、列宽 刷新
    jfrefreshgrid_rhcw(rowheight, colwidth);

    if (isRefreshCanvas) {
        refreshCanvasTimeOut = setTimeout(function () {
            luckysheetrefreshgrid();
        }, 1);
    }

    sheetmanage.storeSheetParamALL();

    window.luckysheet_getcelldata_cache = null;
}

function jfrefreshrange (data, range, cdformat) {
    clearTimeout(refreshCanvasTimeOut);

    if (Store.clearjfundo) {
        Store.jfundo.length  = 0;

        Store.jfredo.push({
            "type": "rangechange",
            "data": Store.flowdata,
            "curdata": data,
            "range": range,
            "sheetIndex": Store.currentSheetIndex,
            "cdformat": $.extend(true, [],  Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].luckysheet_conditionformat_save),
            "curCdformat": cdformat
        });
    }

    // flowdata
    Store.flowdata = data;

    Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].data = Store.flowdata;

    // 条件格式
    if (cdformat != null) {
        Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].luckysheet_conditionformat_save = cdformat;
    }

    // 单元格数据更新联动
    runExecFunction(range, Store.currentSheetIndex, data);

    // 刷新表格
    refreshCanvasTimeOut = setTimeout(function () {
        luckysheetrefreshgrid();
    }, 1);

    // 发送给后台
    for (let s = 0; s < range.length; s++) {
        server.historyParam(Store.flowdata, Store.currentSheetIndex, range[s]);
    }
}

// 删除、增加行列 刷新表格
function jfrefreshgrid_adRC (data, cfg, ctrlType, ctrlValue, calc, filterObj, cf, af, freezen, dataVerification, hyperlink, attechment) {
    let file = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)];
    collaborativeEditBox();
    // merge改变对应的单元格值改变
    let mcData = [];
    for (let m in cfg.merge) {
        let mc = cfg.merge[m];

        for (let r = mc.r; r <= mc.r + mc.rs - 1; r++) {
            for (let c = mc.c; c <= mc.c + mc.cs - 1; c++) {
                if (data[r][c] == null) {
                    data[r][c] = {};
                }

                if (r == mc.r && c == mc.c) {
                    data[r][c].mc = mc;
                } else {
                    data[r][c].mc = { "r": mc.r, "c": mc.c };
                }

                mcData.push({ "r": r, "c": c });
            }
        }
    }

    // 公式链中公式范围改变对应单元格值的改变
    let funcData = [];
    // if(calc.length > 0){
    //     // 取消execFunctionGroupData，改用execFunctionGlobalData
    //     // formula.execFunctionGroupData = data;

    //     for(let i = 0; i < calc.length; i++){
    //         let clc = calc[i];
    //         let clc_r = clc.r, clc_c = clc.c, clc_i = clc.index, clc_funcStr =  getcellFormula(clc_r, clc_c, clc_i, data);

    //         let clc_result = formula.execfunction(clc_funcStr, clc_r, clc_c, clc_i,null, true);
    //         clc.func = clc_result;

    //         if(data[clc_r][clc_c].f == clc_funcStr){
    //             setcellvalue(clc_r, clc_c, data, clc_result[1]);
    //             // funcData存储当前结果没有用处，每次还是需要从calc公式链实时从当前数据中计算比较靠谱
    //             // funcData.push({ "r": clc_r, "c": clc_c });
    //         }
    //     }
    // }
    Store.luckysheetfile[getCurrentSheetIndex()].computeMap = null;
    if (Store.clearjfundo) {
        Store.jfundo.length  = 0;

        Store.jfredo.push({
            "type": ctrlType,
            "sheetIndex": Store.currentSheetIndex,
            "data": Store.flowdata,
            "curData": data,
            "config": $.extend(true, {}, Store.config),
            "curConfig": cfg,
            "ctrlValue": ctrlValue,
            "mcData": mcData,
            "calc": $.extend(true, [], file.calcChain),
            "curCalc": calc,
            "funcData": funcData,
            "filterObj": { "filter_select": $.extend(true, {}, file.filter_select), "filter": $.extend(true, {}, file.filter) },
            "curFilterObj": filterObj,
            "cf": $.extend(true, [], file.luckysheet_conditionformat_save),
            "curCf": cf,
            "af": $.extend(true, [], file.luckysheet_alternateformat_save),
            "curAf": af,
            "freezen": { "freezenhorizontaldata": luckysheetFreezen.freezenhorizontaldata, "freezenverticaldata": luckysheetFreezen.freezenverticaldata },
            "curFreezen": freezen,
            "dataVerification": $.extend(true, {}, file.dataVerification),
            "curDataVerification": dataVerification,
            "hyperlink": $.extend(true, {}, file.hyperlink),
            'attechment': $.extend(true, {}, file.attechment),
            "curHyperlink": hyperlink,
            "curAttechment": attechment,
            "range": file.luckysheet_select_save || [],
            "dataRange": [...(file.luckysheet_select_save || [])]// 保留操作时的选区
        });
    }

    let index = ctrlValue.index,
        len = ctrlValue.len,
        rc = ctrlValue.rc;

    if (ctrlType == "addRC") {
        let direction = ctrlValue.direction,
            restore = ctrlValue.restore;

        let addData = [];
        if (restore) {
            if (rc == "r") {
                let st_r;
                if (direction == "lefttop") {
                    st_r = index;
                } else if (direction == "rightbottom") {
                    st_r = index + 1;
                }
                let ed_r = st_r + len - 1;

                for (let r = st_r; r <= ed_r; r++) {
                    let row = [];
                    for (let c = 0; c < data[0].length; c++) {
                        let cell = data[r][c];
                        row.push(cell);
                    }
                    addData.push(row);
                }
            } else if (rc == "c") {
                let st_c;
                if (direction == "lefttop") {
                    st_c = index;
                } else if (direction == "rightbottom") {
                    st_c = index + 1;
                }
                let ed_c = st_c + len - 1;

                for (let r = 0; r < data.length; r++) {
                    let row = [];
                    for (let c = st_c; c <= ed_c; c++) {
                        let cell = data[r][c];
                        row.push(cell);
                    }
                    addData.push(row);
                }
            }
        }

        server.saveParam("arc", Store.currentSheetIndex, { "index": index, "len": len, "direction": direction, "data": addData }, { "rc": rc });
    } else if (ctrlType == "delRC") {
        server.saveParam("drc", Store.currentSheetIndex, { "index": index, "len": len }, { "rc": rc });
    }

    // Store.flowdata
    Store.flowdata = data;
    file.data = data;

    // config
    Store.config = cfg;
    file.config = Store.config;
    server.saveParam("all", Store.currentSheetIndex, cfg, { "k": "config" });

    // mcData
    for (let i = 0; i < mcData.length; i++) {
        let mcData_r = mcData[i].r,
            mcData_c = mcData[i].c;

        server.saveParam("v", Store.currentSheetIndex, Store.flowdata[mcData_r][mcData_c], { "r": mcData_r, "c": mcData_c });
    }

    // 公式链中公式范围改变对应单元格值的改变
    if (calc.length > 0) {
        // 取消execFunctionGroupData，改用execFunctionGlobalData
        // formula.execFunctionGroupData = data;

        for (let i = 0; i < calc.length; i++) {
            let clc = calc[i];
            let clc_r = clc.r, clc_c = clc.c, clc_i = clc.index, clc_funcStr =  getcellFormula(clc_r, clc_c, clc_i, data);

            let clc_result = formula.execfunction(clc_funcStr, clc_r, clc_c, clc_i, null, true);
            clc.func = clc_result;

            if (data[clc_r][clc_c].f == clc_funcStr) {
                setcellvalue(clc_r, clc_c, data, clc_result[1]);
                // funcData存储当前结果没有用处，每次还是需要从calc公式链实时从当前数据中计算比较靠谱
                // funcData.push({ "r": clc_r, "c": clc_c });
            }
        }
    }

    // calc函数链
    file.calcChain = calc;
    server.saveParam("all", Store.currentSheetIndex, calc, { "k": "calcChain" });
    for (let i = 0; i < funcData.length; i++) {
        let funcData_r = funcData[i].r,
            funcData_c = funcData[i].c;

        server.saveParam("v", Store.currentSheetIndex, Store.flowdata[funcData_r][funcData_c], { "r": funcData_r, "c": funcData_c });
    }

    // 筛选配置
    if (filterObj != null) {
        file.filter_select = filterObj.filter_select;
        file.filter = filterObj.filter;
    } else {
        file.filter_select = null;
        file.filter = null;
    }
    createFilterOptions(file.filter_select, file.filter);
    server.saveParam("all", Store.currentSheetIndex, file.filter_select, { "k": "filter_select" });
    server.saveParam("all", Store.currentSheetIndex, file.filter, { "k": "filter" });

    // 条件格式配置
    file.luckysheet_conditionformat_save = cf;
    server.saveParam("all", Store.currentSheetIndex, file.luckysheet_conditionformat_save, { "k": "luckysheet_conditionformat_save" });

    // 交替颜色配置
    file.luckysheet_alternateformat_save = af;
    server.saveParam("all", Store.currentSheetIndex, file.luckysheet_alternateformat_save, { "k": "luckysheet_alternateformat_save" });

    // 冻结配置
    if (freezen != null) {
        luckysheetFreezen.freezenhorizontaldata = freezen.freezenhorizontaldata;
        luckysheetFreezen.freezenverticaldata = freezen.freezenverticaldata;
    } else {
        luckysheetFreezen.freezenhorizontaldata = null;
        luckysheetFreezen.freezenverticaldata = null;
    }

    // 数据验证
    dataVerificationCtrl.dataVerification = dataVerification;
    file.dataVerification = dataVerification;
    server.saveParam("all", Store.currentSheetIndex, file.dataVerification, { "k": "dataVerification" });

    // 超链接
    hyperlinkCtrl.hyperlink = hyperlink;
    file.hyperlink = hyperlink;
    attachmentCtrl.attechment = attechment;
    file.attechment = attechment;
    server.saveParam("all", Store.currentSheetIndex, file.attechment, { "k": "attechment" });

    server.saveParam("all", Store.currentSheetIndex, file.hyperlink, { "k": "hyperlink" });
    // 附件
    // 行高、列宽刷新
    jfrefreshgrid_rhcw(Store.flowdata.length, Store.flowdata[0].length);
}

// 删除单元格 刷新表格
function jfrefreshgrid_deleteCell (data, cfg, ctrl, calc, filterObj, cf, dataVerification, hyperlink, attechment) {
    let file = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)];
    clearTimeout(refreshCanvasTimeOut);
    collaborativeEditBox();
    // merge改变对应的单元格值改变
    Store.luckysheetfile[getCurrentSheetIndex()].computeMap = null;
    let mcData = [];
    if (JSON.stringify(cfg.merge) == "{}") {
        for (let r = 0; r < data.length; r++) {
            for (let c = 0; c < data[0].length; c++) {
                let cell = data[r][c];

                if (cell != null && cell.mc != null) {
                    delete cell.mc;
                    mcData.push({ "r": r, "c": c });
                }
            }
        }
    } else {
        for (let m in cfg.merge) {
            let mc = cfg.merge[m];

            for (let r = mc.r; r <= mc.r + mc.rs - 1; r++) {
                for (let c = mc.c; c <= mc.c + mc.cs - 1; c++) {
                    if (data[r][c] == null) {
                        data[r][c] = {};
                    }

                    // if(r == mc.r && c == mc.c){
                    //     data[r][c].mc = mc;
                    // }
                    // else{
                    //     data[r][c].mc = { "r": mc.r, "c": mc.c };
                    // }

                    // mcData.push({ "r": r, "c": c });

                    if (r == mc.r && c == mc.c) {
                        if (JSON.stringify(data[r][c].mc) != JSON.stringify(mc)) {
                            data[r][c].mc = mc;
                            mcData.push({ "r": r, "c": c });
                        }
                    } else {
                        let tempMc = { "r": mc.r, "c": mc.c };
                        if (JSON.stringify(data[r][c].mc) != JSON.stringify(tempMc)) {
                            data[r][c].mc = tempMc;
                            mcData.push({ "r": r, "c": c });
                        }
                    }
                }
            }
        }
    }

    // 公式链中公式范围改变对应单元格值的改变
    let funcData = [];
    // if(calc.length > 0){
    //     // formula.execFunctionGroupData = data;

    //     for(let i = 0; i < calc.length; i++){
    //         let clc = calc[i];
    //         let clc_r = clc.r, clc_c = clc.c, clc_i = clc.index, clc_funcStr =  getcellFormula(clc_r, clc_c, clc_i, data);
    //         let clc_result = formula.execfunction(clc_funcStr, clc_r, clc_c, clc_i,null, true);
    //         clc.func = clc_result;

    //         if(data[clc_r][clc_c].f == clc_funcStr){
    //             setcellvalue(clc_r, clc_c, data, clc_result[1]);
    //             funcData.push({ "r": clc_r, "c": clc_c });
    //         }
    //     }
    // }

    if (Store.clearjfundo) {
        Store.jfundo.length  = 0;

        Store.jfredo.push({
            "type": "deleteCell",
            "sheetIndex": Store.currentSheetIndex,
            "ctrl": ctrl,
            "data": Store.flowdata,
            "curData": data,
            "config": $.extend(true, {}, Store.config),
            "curConfig": cfg,
            "mcData": mcData,
            "calc": $.extend(true, [], file.calcChain),
            "curCalc": calc,
            "funcData": funcData,
            "filterObj": { "filter_select": $.extend(true, {}, file.filter_select), "filter": $.extend(true, {}, file.filter) },
            "curFilterObj": filterObj,
            "cf": $.extend(true, [], file.luckysheet_conditionformat_save),
            "curCf": cf,
            "dataVerification": $.extend(true, {}, file.dataVerification),
            "curDataVerification": dataVerification,
            "hyperlink": $.extend(true, {}, file.hyperlink),
            "attechment": $.extend(true, {}, file.attechment),
            "curHyperlink": hyperlink,
            "curAttechment": attechment,
            "range": file.luckysheet_select_save,
            "dataRange": [...file.luckysheet_select_save] // 保留操作时的选区
        });
    }

    // Store.flowdata
    Store.flowdata = data;
    file.data = data;

    // 共享编辑模式
    if (server.allowUpdate) {
        let type = ctrl.type,
            str = ctrl.str,
            edr = ctrl.edr,
            stc = ctrl.stc,
            edc = ctrl.edc;

        let range;
        if (type == 'moveUp') {
            range = {
                "row": [str, data.length - 1],
                "column": [stc, edc]
            };
        } else if (type == 'moveLeft') {
            range = {
                "row": [str, edr],
                "column": [stc, data[0].length - 1]
            };
        }

        server.historyParam(Store.flowdata, Store.currentSheetIndex, range);
    }

    // config
    Store.config = cfg;
    file.config = Store.config;
    server.saveParam("all", Store.currentSheetIndex, cfg, { "k": "config" });

    // mcData
    for (let i = 0; i < mcData.length; i++) {
        let mcData_r = mcData[i].r,
            mcData_c = mcData[i].c;

        server.saveParam("v", Store.currentSheetIndex, Store.flowdata[mcData_r][mcData_c], { "r": mcData_r, "c": mcData_c });
    }

    // 公式链中公式范围改变对应单元格值的改变
    if (calc.length > 0) {
        // formula.execFunctionGroupData = data;

        for (let i = 0; i < calc.length; i++) {
            let clc = calc[i];
            let clc_r = clc.r, clc_c = clc.c, clc_i = clc.index, clc_funcStr =  getcellFormula(clc_r, clc_c, clc_i, data);
            let clc_result = formula.execfunction(clc_funcStr, clc_r, clc_c, clc_i, null, true);
            clc.func = clc_result;

            if (data[clc_r][clc_c].f == clc_funcStr) {
                setcellvalue(clc_r, clc_c, data, clc_result[1]);
                // funcData.push({ "r": clc_r, "c": clc_c });
            }
        }
    }

    // calc函数链
    file.calcChain = calc;
    server.saveParam("all", Store.currentSheetIndex, calc, { "k": "calcChain" });
    for (let i = 0; i < funcData.length; i++) {
        let funcData_r = funcData[i].r,
            funcData_c = funcData[i].c;

        server.saveParam("v", Store.currentSheetIndex, Store.flowdata[funcData_r][funcData_c], { "r": funcData_r, "c": funcData_c });
    }

    // 筛选配置
    if (filterObj != null) {
        file.filter_select = filterObj.filter_select;
        file.filter = filterObj.filter;
    } else {
        file.filter_select = null;
        file.filter = null;
    }
    createFilterOptions(file.filter_select, file.filter);
    server.saveParam("all", Store.currentSheetIndex, file.filter_select, { "k": "filter_select" });
    server.saveParam("all", Store.currentSheetIndex, file.filter, { "k": "filter" });

    // 条件格式配置
    file.luckysheet_conditionformat_save = cf;
    server.saveParam("all", Store.currentSheetIndex, file.luckysheet_conditionformat_save, { "k": "luckysheet_conditionformat_save" });

    // 数据验证
    dataVerificationCtrl.dataVerification = dataVerification;
    file.dataVerification = dataVerification;
    server.saveParam("all", Store.currentSheetIndex, file.dataVerification, { "k": "dataVerification" });

    // 超链接
    hyperlinkCtrl.hyperlink = hyperlink;
    attachmentCtrl.attechment = attechment;
    file.hyperlink = hyperlink;
    file.attechment = attechment;
    server.saveParam("all", Store.currentSheetIndex, file.hyperlink, { "k": "hyperlink" });

    server.saveParam("all", Store.currentSheetIndex, file.attechment, { "k": "attechment" });

    refreshCanvasTimeOut = setTimeout(function () {
        luckysheetrefreshgrid();
    }, 1);
}

// 复制剪切 刷新表格
function jfrefreshgrid_pastcut (source, target, RowlChange) {
    // 单元格数据更新联动
    let execF_rc = {};
    formula.execFunctionExist = [];
    clearTimeout(refreshCanvasTimeOut);
    Store.luckysheetfile[getCurrentSheetIndex()].computeMap = null;
    for (let r = source.range.row[0]; r <= source.range.row[1]; r++) {
        for (let c = source.range.column[0]; c <= source.range.column[1]; c++) {
            if ((r + "_" + c + "_" + source.sheetIndex) in execF_rc) {
                continue;
            }

            execF_rc[r + "_" + c + "_" + source.sheetIndex] = 0;
            formula.execFunctionExist.push({ "r": r, "c": c, "i": source.sheetIndex });
        }
    }

    for (let r = target.range.row[0]; r <= target.range.row[1]; r++) {
        for (let c = target.range.column[0]; c <= target.range.column[1]; c++) {
            if ((r + "_" + c + "_" + target.sheetIndex) in execF_rc) {
                continue;
            }

            execF_rc[r + "_" + c + "_" + target.sheetIndex] = 0;
            formula.execFunctionExist.push({ "r": r, "c": c, "i": target.sheetIndex });
        }
    }

    if (Store.clearjfundo) {
        Store.jfundo.length  = 0;

        Store.jfredo.push({
            "type": "pasteCut",
            "source": source,
            "target": target,
            "RowlChange": RowlChange
        });
    }

    // config
    let rowHeight;
    if (Store.currentSheetIndex == source.sheetIndex) {
        Store.config = source.curConfig;
        rowHeight = source.curData.length;
        Store.luckysheetfile[getSheetIndex(target.sheetIndex)].config = target.curConfig;
    } else if (Store.currentSheetIndex == target.sheetIndex) {
        Store.config = target.curConfig;
        rowHeight = target.curData.length;
        Store.luckysheetfile[getSheetIndex(source.sheetIndex)].config = source.curConfig;
    }

    if (RowlChange) {
        Store.visibledatarow = [];
        Store.rh_height = 0;

        for (let i = 0; i < rowHeight; i++) {
            let rowlen = Store.defaultrowlen;

            if (Store.config.rowlen != null && Store.config.rowlen[i] != null) {
                rowlen = Store.config.rowlen[i];
            }

            if (Store.config.rowhidden != null && Store.config.rowhidden[i] != null) {
                rowlen = Store.config.rowhidden[i];
                Store.visibledatarow.push(Store.rh_height);
                continue;
            } else {
                Store.rh_height += rowlen + 1;
            }

            Store.visibledatarow.push(Store.rh_height);// 行的临时长度分布
        }
        Store.rh_height += 80;
        // sheetmanage.showSheet();

        if (Store.currentSheetIndex == source.sheetIndex) {
            let rowlenArr = computeRowlenArr(target.curData.length, target.curConfig);
            Store.luckysheetfile[getSheetIndex(target.sheetIndex)].visibledatarow = rowlenArr;
        } else if (Store.currentSheetIndex == target.sheetIndex) {
            let rowlenArr = computeRowlenArr(source.curData.length, source.curConfig);
            Store.luckysheetfile[getSheetIndex(source.sheetIndex)].visibledatarow = rowlenArr;
        }
    }

    // Store.flowdata
    if (Store.currentSheetIndex == source.sheetIndex) {
        Store.flowdata = source.curData;
        Store.luckysheetfile[getSheetIndex(target.sheetIndex)].data = target.curData;
    } else if (Store.currentSheetIndex == target.sheetIndex) {
        Store.flowdata = target.curData;
        Store.luckysheetfile[getSheetIndex(source.sheetIndex)].data = source.curData;
    }
    Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].data = Store.flowdata;

    // luckysheet_select_save
    if (Store.currentSheetIndex == target.sheetIndex) {
        Store.luckysheet_select_save = [{ "row": target.range.row, "column": target.range.column }];
    } else {
        Store.luckysheet_select_save = [{ "row": source.range.row, "column": source.range.column }];
    }
    if (Store.luckysheet_select_save.length > 0) {
        // 有选区时，刷新一下选区
        selectHightlightShow();
    }

    // 条件格式
    Store.luckysheetfile[getSheetIndex(source.sheetIndex)].luckysheet_conditionformat_save = source.curCdformat;
    Store.luckysheetfile[getSheetIndex(target.sheetIndex)].luckysheet_conditionformat_save = target.curCdformat;

    // 数据验证
    if (Store.currentSheetIndex == source.sheetIndex) {
        dataVerificationCtrl.dataVerification = source.curDataVerification;
    } else if (Store.currentSheetIndex == target.sheetIndex) {
        dataVerificationCtrl.dataVerification = target.curDataVerification;
    }
    Store.luckysheetfile[getSheetIndex(source.sheetIndex)].dataVerification = source.curDataVerification;
    Store.luckysheetfile[getSheetIndex(target.sheetIndex)].dataVerification = target.curDataVerification;

    formula.execFunctionExist.reverse();
    formula.execFunctionGroup(null, null, null, null, target.curData);
    formula.execFunctionGlobalData = null;

    let index = getSheetIndex(Store.currentSheetIndex);
    let file = Store.luckysheetfile[index];
    file.scrollTop  = $("#luckysheet-cell-main").scrollTop();
    file.scrollLeft = $("#luckysheet-cell-main").scrollLeft();

    sheetmanage.showSheet();

    refreshCanvasTimeOut = setTimeout(function () {
        luckysheetrefreshgrid();
    }, 1);

    sheetmanage.storeSheetParamALL();

    // saveparam
    // 来源表
    server.saveParam("all", source.sheetIndex, source.curConfig, { "k": "config" });
    // 目的表
    server.saveParam("all", target.sheetIndex, target.curConfig, { "k": "config" });

    // 来源表
    server.historyParam(source.curData, source.sheetIndex, { "row": source.range.row, "column": source.range.column });
    // 目的表
    server.historyParam(target.curData, target.sheetIndex, { "row": target.range.row, "column": target.range.column });

    // 来源表
    server.saveParam("all", source.sheetIndex, source.curCdformat, { "k": "luckysheet_conditionformat_save" });
    // 目的表
    server.saveParam("all", target.sheetIndex, target.curCdformat, { "k": "luckysheet_conditionformat_save" });

    // 来源表
    server.saveParam("all", source.sheetIndex, source.curDataVerification, { "k": "dataVerification" });
    // 目的表
    server.saveParam("all", target.sheetIndex, target.curDataVerification, { "k": "dataVerification" });
}

// 行高、列宽改变 刷新表格
function jfrefreshgrid_rhcw (rowheight, colwidth, isRefreshCanvas = true, isReCreateAssistCanvas = true, init = false) {
    rhchInit(rowheight, colwidth, getCurrentSheetIndex(), init);
    clearTimeout(refreshCanvasTimeOut);
    sheetmanage.storeSheetParam();
    // 行高列宽改变时 重新计算sparklines
    let calcChain = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].calcChain;

    if (calcChain != null && calcChain.length > 0) {
        if (Store.config.rowlen == null) {
            Store.config.rowlen = {};
        }

        if (Store.config.columnlen == null) {
            Store.config.columnlen = {};
        }

        for (let i = 0; i < calcChain.length; i++) {
            let r = calcChain[i].r, c = calcChain[i].c, index = calcChain[i].index;

            if (index == Store.currentSheetIndex && Store.flowdata[r][c] != null && Store.flowdata[r][c].spl != null && ((r in Store.config.rowlen) || (c in Store.config.columnlen))) {
                window.luckysheetCurrentRow = r;
                window.luckysheetCurrentColumn = c;
                window.luckysheetCurrentFunction = Store.flowdata[r][c].f;

                let fp = $.trim(formula.functionParserExe(Store.flowdata[r][c].f));
                let sparklines = new Function("return " + fp)();
                Store.flowdata[r][c].spl = sparklines;

                server.saveParam("v", Store.currentSheetIndex, Store.flowdata[r][c], { "r": r, "c": c });
            }
        }

        Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].data = Store.flowdata;
    }

    // 批注框同步
    luckysheetPostil.positionSync();
    // 选区同步
    selectHightlightShow();
    // 协同提示框同步
    collaborativeEditBox();
    // 改变单元格行高，复制虚线框同步
    if ($(".luckysheet-selection-copy").is(":visible")) {
        selectionCopyShow();
    }

    // 改变单元格行高，选区下拉icon隐藏
    if ($("#luckysheet-dropCell-icon").is(":visible")) {
        $("#luckysheet-dropCell-icon").remove();
    }

    // 有冻结状态时，同步行高、列宽
    if (luckysheetFreezen.freezenhorizontaldata != null && luckysheetFreezen.freezenverticaldata != null) {
        let row_st = luckysheetFreezen.freezenhorizontaldata[1] - 1;
        let col_st = luckysheetFreezen.freezenverticaldata[1] - 1;

        let scrollTop = luckysheetFreezen.freezenhorizontaldata[2];
        let scrollLeft = luckysheetFreezen.freezenverticaldata[2];

        let top = Store.visibledatarow[row_st] - 2 - scrollTop + Store.columnHeaderHeight;
        let freezenhorizontaldata = [
            Store.visibledatarow[row_st],
            row_st + 1,
            scrollTop,
            luckysheetFreezen.cutVolumn(Store.visibledatarow, row_st + 1),
            top
        ];
        let left = Store.visibledatacolumn[col_st] - 2 - scrollLeft + Store.rowHeaderWidth;
        let freezenverticaldata = [
            Store.visibledatacolumn[col_st],
            col_st + 1,
            scrollLeft,
            luckysheetFreezen.cutVolumn(Store.visibledatacolumn, col_st + 1),
            left
        ];

        luckysheetFreezen.saveFreezen(freezenhorizontaldata, top, freezenverticaldata, left);
        luckysheetFreezen.createFreezenHorizontal(freezenhorizontaldata, top);
        luckysheetFreezen.createFreezenVertical(freezenverticaldata, left);
        if (isReCreateAssistCanvas)luckysheetFreezen.createAssistCanvas();
    } else if (luckysheetFreezen.freezenhorizontaldata != null) {
        let row_st = luckysheetFreezen.freezenhorizontaldata[1] - 1;
        let scrollTop = luckysheetFreezen.freezenhorizontaldata[2];

        let top = Store.visibledatarow[row_st] - 2 - scrollTop + Store.columnHeaderHeight;
        let freezenhorizontaldata = [
            Store.visibledatarow[row_st],
            row_st + 1,
            scrollTop,
            luckysheetFreezen.cutVolumn(Store.visibledatarow, row_st + 1),
            top
        ];

        luckysheetFreezen.saveFreezen(freezenhorizontaldata, top, null, null);
        luckysheetFreezen.createFreezenHorizontal(freezenhorizontaldata, top);
        if (isReCreateAssistCanvas)luckysheetFreezen.createAssistCanvas();
    } else if (luckysheetFreezen.freezenverticaldata != null) {
        let col_st = luckysheetFreezen.freezenverticaldata[1] - 1;
        let scrollLeft = luckysheetFreezen.freezenverticaldata[2];

        let left = Store.visibledatacolumn[col_st] - 2 - scrollLeft + Store.rowHeaderWidth;
        let freezenverticaldata = [
            Store.visibledatacolumn[col_st],
            col_st + 1,
            scrollLeft,
            luckysheetFreezen.cutVolumn(Store.visibledatacolumn, col_st + 1),
            left
        ];

        luckysheetFreezen.saveFreezen(null, null, freezenverticaldata, left);
        luckysheetFreezen.createFreezenVertical(freezenverticaldata, left);
        if (isReCreateAssistCanvas)luckysheetFreezen.createAssistCanvas();
    } else {
        // 有筛选标志时，同步筛选按钮和筛选范围位置
        if ($("#luckysheet-filter-options-sheet" + Store.currentSheetIndex + " .luckysheet-filter-options").length > 0) {
            $("#luckysheet-filter-options-sheet" + Store.currentSheetIndex + " .luckysheet-filter-options").each(function (i, e) {
                let str = $(e).data("str"), cindex = $(e).data("cindex");
                let left = Store.visibledatacolumn[cindex] - 20;
                let top = str - 1 == -1 ? 0 : Store.visibledatarow[str - 1];
                top = top + (Store.visibledatarow[str] - top - 15 - 1) / 2;
                $(e).css({ "left": left, "top": top });
            });
        }
    }

    if ($("#luckysheet-filter-selected-sheet" + Store.currentSheetIndex).length > 0) {
        let luckysheet_filter_save = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].filter_select;

        let r1 = luckysheet_filter_save.row[0],
            r2 = luckysheet_filter_save.row[1];
        let c1 = luckysheet_filter_save.column[0],
            c2 = luckysheet_filter_save.column[1];

        let row = Store.visibledatarow[r2],
            row_pre = r1 - 1 == -1 ? 0 : Store.visibledatarow[r1 - 1];
        let col = Store.visibledatacolumn[c2],
            col_pre = c1 - 1 == -1 ? 0 : Store.visibledatacolumn[c1 - 1];

        $("#luckysheet-filter-selected-sheet" + Store.currentSheetIndex).css({
            "left": col_pre,
            "width": col - col_pre - 1,
            "top": row_pre,
            "height": row - row_pre - 1
        });
    }
    sheetmanage.showSheet();

    if (isRefreshCanvas) {
        refreshCanvasTimeOut = setTimeout(function () {
            luckysheetrefreshgrid();
        }, 1);
    }
}

// Refresh the canvas display data according to scrollHeight and scrollWidth
function luckysheetrefreshgrid (scrollWidth, scrollHeight) {
    if (Store.suspend) return;
    formula.groupValuesRefresh();

    if (scrollWidth == null) {
        scrollWidth = $("#luckysheet-cell-main").scrollLeft();
    }
    if (scrollHeight == null) {
        scrollHeight = $("#luckysheet-cell-main").scrollTop();
    }

    if (luckysheetFreezen.freezenverticaldata != null || luckysheetFreezen.freezenhorizontaldata != null) {
        let freezen_horizon_px, freezen_horizon_ed, freezen_horizon_scrollTop;
        let freezen_vertical_px, freezen_vertical_ed, freezen_vertical_scrollTop;
        let drawWidth = Store.luckysheetTableContentHW[0], drawHeight = Store.luckysheetTableContentHW[1];

        if (luckysheetFreezen.freezenverticaldata != null && luckysheetFreezen.freezenhorizontaldata != null) {
            freezen_horizon_px = luckysheetFreezen.freezenhorizontaldata[0];
            freezen_horizon_ed = luckysheetFreezen.freezenhorizontaldata[1];
            freezen_horizon_scrollTop = luckysheetFreezen.freezenhorizontaldata[2];

            freezen_vertical_px = luckysheetFreezen.freezenverticaldata[0];
            freezen_vertical_ed = luckysheetFreezen.freezenverticaldata[1];
            freezen_vertical_scrollTop = luckysheetFreezen.freezenverticaldata[2];

            // 左上canvas freezen_3
            luckysheetDrawMain(
                freezen_vertical_scrollTop,
                freezen_horizon_scrollTop,
                freezen_vertical_px,
                freezen_horizon_px,
                1,
                1,
                null,
                null,
                "freezen_3"
            );

            // 上右canvas freezen_4
            luckysheetDrawMain(
                scrollWidth + freezen_vertical_px - freezen_vertical_scrollTop,
                freezen_horizon_scrollTop,
                drawWidth - freezen_vertical_px + freezen_vertical_scrollTop,
                freezen_horizon_px,
                1,
                1,
                null,
                null,
                "freezen_4"
            );

            // 左下canvas freezen_7
            luckysheetDrawMain(
                freezen_vertical_scrollTop,
                scrollHeight + freezen_horizon_px - freezen_horizon_scrollTop,
                freezen_vertical_px,
                drawHeight - freezen_horizon_px + freezen_horizon_scrollTop,
                1,
                1,
                null,
                null,
                "freezen_7"
            );

            // 右下canvas luckysheetTableContent
            luckysheetDrawMain(
                scrollWidth + freezen_vertical_px - freezen_vertical_scrollTop,
                scrollHeight + freezen_horizon_px - freezen_horizon_scrollTop,
                drawWidth - freezen_vertical_px + freezen_vertical_scrollTop,
                drawHeight - freezen_horizon_px + freezen_horizon_scrollTop,
                freezen_vertical_px - freezen_vertical_scrollTop + Store.rowHeaderWidth,
                freezen_horizon_px - freezen_horizon_scrollTop + Store.columnHeaderHeight
            );

            // 标题
            luckysheetDrawgridColumnTitle(freezen_vertical_scrollTop, freezen_vertical_px, Store.rowHeaderWidth);
            luckysheetDrawgridColumnTitle(
                scrollWidth + freezen_vertical_px - freezen_vertical_scrollTop,
                drawWidth - freezen_vertical_px + freezen_vertical_scrollTop,
                freezen_vertical_px - freezen_vertical_scrollTop + Store.rowHeaderWidth
            );

            luckysheetDrawgridRowTitle(freezen_horizon_scrollTop, freezen_horizon_px, Store.columnHeaderHeight);
            luckysheetDrawgridRowTitle(
                scrollHeight + freezen_horizon_px - freezen_horizon_scrollTop,
                drawHeight - freezen_horizon_px + freezen_horizon_scrollTop,
                freezen_horizon_px - freezen_horizon_scrollTop + Store.columnHeaderHeight
            );
        } else if (luckysheetFreezen.freezenhorizontaldata != null) {
            freezen_horizon_px = luckysheetFreezen.freezenhorizontaldata[0];
            freezen_horizon_ed = luckysheetFreezen.freezenhorizontaldata[1];
            freezen_horizon_scrollTop = luckysheetFreezen.freezenhorizontaldata[2];

            luckysheetDrawMain(
                scrollWidth,
                freezen_horizon_scrollTop,
                drawWidth,
                freezen_horizon_px,
                1,
                1,
                null,
                null,
                "freezen_h"
            );
            luckysheetDrawMain(
                scrollWidth,
                scrollHeight + freezen_horizon_px - freezen_horizon_scrollTop,
                drawWidth,
                drawHeight - freezen_horizon_px + freezen_horizon_scrollTop,
                null,
                freezen_horizon_px - freezen_horizon_scrollTop + Store.columnHeaderHeight
            );

            luckysheetDrawgridColumnTitle(scrollWidth, drawWidth, null);

            luckysheetDrawgridRowTitle(freezen_horizon_scrollTop, freezen_horizon_px, Store.columnHeaderHeight);
            luckysheetDrawgridRowTitle(
                scrollHeight + freezen_horizon_px - freezen_horizon_scrollTop,
                drawHeight - freezen_horizon_px + freezen_horizon_scrollTop,
                freezen_horizon_px - freezen_horizon_scrollTop + Store.columnHeaderHeight
            );
        } else if (luckysheetFreezen.freezenverticaldata != null) {
            freezen_vertical_px = luckysheetFreezen.freezenverticaldata[0];
            freezen_vertical_ed = luckysheetFreezen.freezenverticaldata[1];
            freezen_vertical_scrollTop = luckysheetFreezen.freezenverticaldata[2];

            luckysheetDrawMain(
                freezen_vertical_scrollTop,
                scrollHeight,
                freezen_vertical_px,
                drawHeight,
                1,
                1,
                null,
                null,
                "freezen_v"
            );
            luckysheetDrawMain(
                scrollWidth + freezen_vertical_px - freezen_vertical_scrollTop,
                scrollHeight,
                drawWidth - freezen_vertical_px + freezen_vertical_scrollTop,
                drawHeight,
                freezen_vertical_px - freezen_vertical_scrollTop + Store.rowHeaderWidth,
                null
            );

            luckysheetDrawgridRowTitle(scrollHeight, drawHeight, null);

            luckysheetDrawgridColumnTitle(freezen_vertical_scrollTop, freezen_vertical_px, Store.rowHeaderWidth);
            luckysheetDrawgridColumnTitle(
                scrollWidth + freezen_vertical_px - freezen_vertical_scrollTop,
                drawWidth - freezen_vertical_px + freezen_vertical_scrollTop,
                freezen_vertical_px - freezen_vertical_scrollTop + Store.rowHeaderWidth
            );
        }
    } else {
        if ($("#luckysheetTableContent").length == 0) {
            return;
        }
        let luckysheetTableContent = $("#luckysheetTableContent").get(0).getContext("2d");
        luckysheetDrawMain(scrollWidth, scrollHeight);

        // luckysheetTableContent.clearRect(0, 0, 46, 20);

        luckysheetDrawgridColumnTitle(scrollWidth);
        luckysheetDrawgridRowTitle(scrollHeight);

        // 清除canvas左上角区域 防止列标题栏序列号溢出显示

        luckysheetTableContent.clearRect(0, 0, (Store.rowHeaderWidth * Store.devicePixelRatio - 1), (Store.columnHeaderHeight * Store.devicePixelRatio - 1));
    }
}

export {
    jfrefreshgrid,
    jfrefreshgridall,
    jfrefreshrange,
    jfrefreshgrid_adRC,
    jfrefreshgrid_deleteCell,
    jfrefreshgrid_pastcut,
    jfrefreshgrid_rhcw,
    luckysheetrefreshgrid
};
